Groebner-bases approach to fast chase decoding of generalized reed-solomon codes

ABSTRACT

An application specific integrated circuit (ASIC) tangibly encodes a program of instructions executable by the integrated circuit to perform a method for fast Chase decoding of generalized Reed-Solomon (GRS) codes. The method includes using outputs of a syndrome-based hard-decision (HD) algorithm to find an initial Groebner basis G for a solution module of a key equation, upon failure of HD decoding of a GRS codeword received by the ASIC from a communication channel; traversing a tree of error patterns on a plurality of unreliable coordinates to adjoin a next weak coordinate, where vertices of the tree of error patterns correspond to error patterns, and edges connect a parent error pattern to a child error pattern having exactly one additional non-zero value, to find a Groebner basis for each adjoining error location; and outputting an estimated transmitted codeword when a correct error vector has been found.

BACKGROUND Technical Field

Embodiments of the present disclosure are directed to methods of forming error correcting codes.

Discussion of the Related Art

In coding theory, generalized Reed-Solomon (GRS) codes form a class of error-correcting codes (ECCs) that are constructed using finite fields. GRS codes can be defined as follows. Let q be a prime power, and let

_(q) be the finite field of q elements. We will consider a primitive GRS code, C, of length n:=q−1 and designed distance d∈

*, d≥2. Note that since the most general GRS code, as defined, e.g., in Section 5.1 of R, M. Roth, Introduction to Coding Theory, Cambridge University Press, 2006, the contents of which are herein incorporated by reference in their entirety, may be obtained by shortening a primitive GRS code, there is no loss of generality in considering only primitive GRS codes. Let ã=(ã₀, . . . , ã_(n−1))∈(

*_(q))^(n) be a vector of non-zero elements. For a vector f=(f₀, f₁, . . . , f_(n−1))∈

_(q) ^(n), let f(X):=f₀+f₁X+ . . . +f_(n−1)X^(n−1)∈

_(q)[X]. Now C∈

_(q) ^(n) is defined as the set of all vectors f∈

_(q) ^(n) for which ã(X)⊙f(X) has roots 1, α, . . . , α^(d−2) for some fixed primitive α∈

_(q), where (-⊙-) stands for coefficient-wise multiplication of polynomials: for f(X)=Σ_(i=0) ^(r)f_(i)X^(i) and g(X)=Σ_(i=0) ^(s)g_(i)X^(i), let m:=min[r, s}, and define f(X)⊙g(X):=Σ_(i=0) ^(m)f_(i)g_(i)X^(i). GRS codes allow a precise control over the number of symbol errors and erasures correctable by the code during code design, in particular, it is possible to design GRS codes that can correct multiple symbol errors and erasures. GRS codes can also be easily decoded using an algebraic method known as syndrome decoding, This can simplify the design of the decoder for these codes by using small, low-power electronic hardware.

The syndrome of a received codeword y=x+e, where x is the transmitted codeword and e is an error pattern, is defined in terms of a parity matrix H. A parity check matrix of a linear code C is a generator matrix of the, dual code C^(⊥), which means that a codeword c is ire C iff the matrix-vector product Hc=0. Then, the syndrome of the received word y=x+e is defined as S=Hy=H(x+e)=Hx+He=0+He=He. For GRS codes, it is useful to work with a syndrome that corresponds to a particular parity-check matrix. For j∈{0, . . . , d−2}, let S_(j)=S_(j) ^((y)):=(ã⊙y)(α^(j)). The syndrome polynomial associated with y is S^((y))(X):=S₀+S₁X+ . . . +S_(d−2)X^(d−2). By the definition of a GRS code, the same syndrome polynomial is associated with e. In terms of syndromes, the main computation in decoding GRS codes is to determine polynomials ω(X), σ(X)∈

_(q)[X], that satisfy the following equation, known as a key equation:

ω≡Sσmod(X ^(d−1)),

where S=S^((y)) is the syndrome polynomial, X is a free variable in the polynomial, ω(X)∈

_(q)[X] is the error evaluator polynomial (EEP), defined by ω(X):=Σ_(i=1) ^(ε)β_(i)α_(i)Π_(j≠i) (1−α_(j)X), σ(X)∈

₂ _(m) [X] is the error locator polynomial (ELIC), defined by σ(X):=Π_(i=1) ^(ε)(1+α_(i)X), where ε∈{1, . . . , n} is the number of errors, α₁, . . . , α_(ε)∈

*_(q) are the error locators, that is, field elements pointing to the location of the errors, β₁, . . . , β_(ε)∈

*_(q) are the corresponding error values, and a_(i):=ã_(i), for the i′∈{0, . . . , n−1} with α_(i)=α^(i)′.

The BerlekampMassey (BM) algorithm is an algorithm for decoding GRS codes that finds an estimated ELP C(X)=1+C₁X+C₂X²+ . . . +C_(L)X^(L) which results in zero coefficients for X^(k) in S(X)C(X) for k=L, . . . , d−2 S_(k)+C₁S_(k−1)+ . . . +C_(L)S_(k−L)=0, where L is the number of errors found by the algorithm, N=d−1 is the total number of syndromes, S_(i) is the coefficient of X^(i) in the syndrome polynomial 8(X) for all i, and k is an index that ranges from L to (N−1). Note that once the decoder has an estimate of the ELP, it can calculate an estimate of the EEP by the key equation. Note also that having both the ELP and the EEP, the decoder can find both the error locators and the error values, and therefore the error vector e itself, in the following way. The error locators are, by definition, the inverses of the roots of the EEP, The error values can be found using Forney's formula:

${\beta_{j} = {{- \frac{\alpha_{j}}{a_{j}}} \cdot \frac{\varrho \left( \alpha_{j}^{- 1} \right)}{\sigma^{\prime}\left( \alpha_{j}^{- 1} \right)}}},{j = 1},\ldots \mspace{14mu},ɛ,$

where for a polynomial f(X)=Σ_(i=0) ^(m)γ_(i)X¹, f′(X):=Σ_(i=1) ^(m)iγ_(i)X^(i−1) is the formal derivative.

The BM algorithm begins by initializing C(X) to 1, L to zero; B(X) (a copy of the last C(X) since L was updated) to 1, b (a copy of the last discrepancy d since L was updated and initialized) to 1; and m (the number of iterations since L, B(X), and b were updated and initialized) to 1. The algorithm iterates from k=0 to N−1. At each iteration k of the algorithm, a discrepancy d is calculated:

d=S _(k)+C_(j) S _(k−1) + . . . +C _(L) S _(s−L).

If d is zero, C(X) and L are assumed correct for the moment, in is incremented, and the algorithm continues.

If d is not zero and 2L>k, C(X) is adjusted so that a recalculation of d would be zero;

C(X)=C(X)−(d/b)X ^(m) B(X).

The X^(m) term shifts B(X) to follow the syndromes corresponding to b. If the previous update of L occurred on iteration j, then m=k−j, and a recalculated discrepancy would be:

d=S _(k) +C ₁ S _(k−1)+ . . . −(d/b)(S _(j) +B ₁ S _(j−1)+ . . . ).

This would change a recalculated discrepancy to: d=d−(d/b)b=d−d=0. Then, m is incremented, and the algorithm continues.

On the other hand, if d is not zero and 2L≤n, a copy of C is saved in vector T, C(X) is adjusted as above, B is updated from T, L is reset to (k+1−L), the discrepancy d is saved as b, in is reset to 1, and the algorithm continues.

A Chien search is an algorithm for determining roots of polynomials over a finite field, such as ELPs encountered in decoding GRS codes. Let a be a primitive element of a finite field. Chien's search tests the non-zero elements in the field in the generator's order α⁰, α¹, α², . . . In this way, every non-zero field element is checked. If at any stage the resultant polynomial evaluates to zero, then the associated element is a root.

Hard information for a received symbol in F_(q) is the estimated symbol value, i.e., one of 0, 1, α, . . . , α^(q−2), while “soft information” includes both an estimated value and the reliability of this estimation. This reliability may take many forms, but one common form is the probability, or an estimation of this probability, that the estimation is correct, possibly plus a subset of F_(q) of the most probable alternative estimates for the received symbol. For example, if symbols of the GRS code are mapped to Quadrature Amplitude Modulation (QAM) symbols and transmitted through an Additive White Gaussian Noise (AWGN) channel, then the typical hard information may be obtained from the closest QAM symbol to the received coordinate, while for soft information, the reliability can be obtained by some decreasing function of the distance between the received coordinate and the closest QAM symbol, and the subset of F_(q) of the most probable alternative estimates may be, e.g., the symbols corresponding to the 2^(nd), 3^(rd), . . . , M-th (for some M≤q), closest QAM symbols to the received coordinate.

In hard-decision (HD) decoding, the hard-information vector (per-coordinate symbol estimates) is used as the input of an error-correcting code (ECC) decoder, while in soft-decision (SD) decoding, a soft information vector, e.g., per-coordinate reliability vector and, for each coordinate that is considered unreliable, a subset of F_(q) consisting of the most probable alternative estimates, on top of the hard-information vector, is used as the input of the ECC decoder.

As another example, in generalized concatenated coding schemes that may be employed in flash-memory controllers, decoders of per-row binary codes may return estimated symbols for GRS codes that work between different rows. In such a case, each per row binary decoder may output a single estimated GRS symbol or an indication of erasure in case of HD decoding, while SD decoding of the per-row binary codes may result in SD information for the inter-row GRS codes. In the case of a single-level cell (SLC) flash memory, in which each cell stores a single bit, hard information for the per-row binary codes is obtained with a single read (single threshold), while increasingly refined soft information is obtained from additional reads.

Symbols with a high enough reliability may be considered “strong”, while the remaining symbols may be considered “weak”.

Chase decoding is a simple and general method for SD decoding for both binary and non-binary codes. See D. Chase, “A Class of Algorithms for Decoding Block Codes With Channel Measurement Information”, IEEE Trans, inform. Theory, Vol. IT-18, pp. 170-182, January 1972, the contents of which are herein incorporated by reference in their entirety. In its simplest form, in case of HD decoding failure, “soft” reliability information is used to distinguish between reliable and non-reliable coordinates of a received word. The decoder then tries to replace the symbols on the weak coordinates by the symbol-vectors in some pre-defined list. For each such replacement, the decoder performs HD decoding. If the number of errors on the reliable coordinates is not above the HD decoding radius of the code and the hypothesized replacement vector is close enough to the transmitted vector on the non-reliable coordinates, in terms of Hamming distance, then HD decoding will succeed.

Consider now two replacement vectors that differ on a single coordinate. In a naïve application of Chase decoding, the similarity between these two replacement vectors is ignored, and two applications of HD decoding are required. In fast Chase decoding, intermediate results from the HD decoding of the first pattern are saved, and used to significantly reduce the complexity of HD decoding of the second, almost identical, pattern.

Recently, Wu, “Fast Chase decoding algorithms and architectures for Reed-Solomon codes”, IEEE Trans. Inform. Theory, vol. 58, no. 1, pp. 109-129, January 2012, the contents of which are herein incorporated by reference in their entirety, hereinafter Wn2012, introduced a new fast Chase decoding algorithm for Reed-Solomon (RS) codes for the case where the HD decoder is based on the Berlekamp-Massey (BM) algorithm. The basic form of Wu's algorithm enables avoiding multiple applications of the BM algorithm, but still requires an exhaustive root search, such as a Chien search, for each replacement vector. To avoid also unnecessary Chien searches, Wu suggests a stopping criterion for significantly reducing the probability of an unnecessary Chien search, while never missing the required Chien search, at the cost of slightly degrading the performance. However, Wu's method is conceptually complicated. There are 8 distinct cases to consider, and a considerable modification is required for working in the frequency domain, as an alternative method for avoiding Chien searches, etc. In addition, Wu's method is not capable of handling the case where the total number of errors is larger than d−1.

SUMMARY

Exemplary embodiments of the disclosure provide a new fast Chase algorithm for generalized RS (GRS) codes for syndrome-based HD decoders. The new decoder is conceptually simpler than Wu's, and is based on two applications of Koetter's algorithm for each additional modified symbol. Also, the new decoder is automatically suitable for application in the frequency domain, by tracking evaluation vectors of both a polynomial and its formal derivative, Embodiments of the disclosure also provide a new stopping criterion for avoiding unnecessary Chien searches in a fast Chase algorithm according to an embodiment. An embodiment of an algorithm is somewhat more complicated than Wu's algorithm, but, as opposed to Wu's algorithm, is capable of working when the total number of errors is strictly larger than d−1, where d is the minimum distance of the decoded GRS code. Another embodiment of an algorithm works when the total number of errors is smaller than d−1 and has a complexity similar to that of Wu's algorithm”.

According to an embodiment of the disclosure, there is provided an application specific integrated circuit (ASIC) tangibly encoding a program of instructions executable by the integrated circuit to perform a method for fast Chase decoding of generalized Reed-Solomon (GRS) codes. The method includes using outputs of a syndrome-based hard-decision (HD) algorithm to find an initial Groebner basis G={g₀=(g₀₀, g₀₁), g₁=(g₁₀, g₁₁)} for a solution module of a key equation, upon failure of RD decoding of a GRS codeword received by the ASIC from a communication channel; traversing a tree of error patterns in

E_(i₁) × … × E_(i_(n₀))

on a plurality of unreliable coordinates to adjoin a next weak coordinate wherein n₀ is a number of the unreliable coordinates, i₁, . . . , i_(n) ₀ are the unreliable coordinates, vertices of the tree of error patterns correspond to error patterns, and edges connect a parent error pattern to a child error pattern having exactly one additional non-zero value, to find a Groebner basis G⁺ for each adjoining error location; and outputting an estimated transmitted codeword {circumflex over (x)}:=y+ê when correct error vector ê has been found.

According to a further embodiment of the disclosure, the syndrome-based HD algorithm is selected from a group that includes the Beriekamp-Massey (BM) algorithm and Fitzpatrick's algorithm.

According to a further embodiment of the disclosure, finding an initial Groebner basis G includes defining polynomials b₁:=(Sσ mod X^(d−1), σ), and b₂ (SX^(m)B mod X^(d−1), X^(m)B), wherein S is the syndrome polynomial, σ is the estimated ELP output by the BM algorithm, m is the number of iterations since the last linear feedback shift register (LFSR) length change in the BM algorithm, and B is a polynomial output from the BM algorithm that is a copy of the last estimated ELP a before the LFSR length L was updated; and outputting one of (1) c{b₁, b₂} as the Groebner basis when leading monomials of b₁ and b₂ contain distinct unit vectors, for a non-zero constant c; (2) {d(b₁−cX¹b₂), db₂} as the Groebner basis when the leading monomials contain a same unit vector and the leading monomial of b₁ is at least as large as that of b₂ Wherein c∈K* and l∈N are chosen such that the leading monomial of b₂ is canceled and d is a non-zero constant, or (3) {db₁, d(b₂−cX¹b₁)} as the Groebner basis when the leading monomials contain the same unit vector and the leading monomial of b₂ is strictly larger than that of b₁, wherein c∈K* and l∈N* are chosen such that the leading monomial of b₂ is canceled and d is a noxa-zero constant.

According to a further embodiment of the disclosure, traversing a tree of error patterns to find a Groebner basis G⁺ for each adjoining error location includes calculating a root discrepancy Δ_(j) ^(rt):=g_(j1)(α_(r) ⁻¹for j=0 and 1, wherein g₀=(g₀₀(X), g₀₁(X)) and g₁=(g₁₀(X), g₁₁(X)) constitute a current Groebner basis and α_(r) is a next error location and r is a number of error locations; setting, when a set

${J:={\left\{ {j \in \left\{ {0,1} \right\}} \middle| {\Delta_{j}^{rt} \neq 0} \right\} \neq \varnothing}},{g_{j}^{+}:={c\left( {g_{j} - {\frac{\Delta_{j}^{rt}}{\Delta_{j^{*}}^{rt}}g_{j^{*}}}} \right)}}$

when (j≠j*), wherein j*∈J is such that a leading monomial of g_(j)* is a minimum leading monomial of (g_(j)) for all j∈J and c is a non-zero constant, or g⁺ _(j):=c(X−α_(r) ⁻¹)g_(j*) when j=j*, wherein X is a free variable; setting g_(j):=g⁺ _(j) for j=0 and 1; calculating a derivative discrepancy Δ_(j) ^(der):=β_(r)a_(r)g′_(j1)(α_(r) ⁻¹)+α_(r)g_(j0)(α_(r) ⁻) for j=0 and 1, wherein β_(r) is a value of location a_(r), and g′_(j1)(X) is a formal derivative of g_(f1)(X); setting, when a set

${J:={\left\{ {j \in \left\{ {0,1} \right\}} \middle| {\Delta_{j}^{der} \neq 0} \right\} \neq \varnothing}},{g_{j}^{+}:={c\left( {g_{j} - {\frac{\Delta_{j}^{der}}{\Delta_{j^{*}}^{der}}g_{j^{*}}}} \right)}}$

when (≠j), wherein j*∈J is such that a leading monomial of M(g_(j*))=a minimum leading monomial of (g_(i)) for j∈J and c is a non-zero constant, or g⁺ _(j):=c(X−α_(r) ⁻¹)g_(j*) when j=j*.

According to a further embodiment of the disclosure, the method includes, when set J:={j∈{0, 1}|Δ_(j) ^(rt)≠0}=Øor when set J:={j∈{0, 1}Δ_(j) ^(der)≠0}=Ø, setting g⁺ _(j):=g_(j) for j=0, 1, where g⁺ ₀=(g⁺ ₀₀, g⁺ ₀₁) and g⁺ ₁=(g⁺ ₁₀, g⁺ ₁₁) is a Groebner basis G⁺ for the next error locator.

According to a further embodiment of the disclosure, the method includes determining whether a root discrepancy is zero for j=1 and a derivative discrepancy is zero for j=1, and stopping setting of g⁺ _(j), if it is determined that both the root discrepancy and the derivative discrepancy are zero for j=1.

According to a further embodiment of the disclosure, the method includes tracking a degree of Groebner basis function g₀₀ with a variable d₀ by increasing d₀ by 1 whenever j*=0.

According to a further embodiment of the disclosure, the method includes tracking two polynomials g₀₁(X), g₁₁(X); and calculating, g₁₀(α_(r) ⁻¹) by using the key equation for j=0, 1.

According to a further embodiment of the disclosure, calculating g_(j0)(α_(r) ⁻¹) includes calculating and storing, for k=2t−δ−1. to 2t−2, {tilde over (B)}_(k+1)=α_(r) ⁻¹. {tilde over (B)}_(k)−(g_(j1))_(2t−1−k) and result=result+S_(k+1){tilde over (B)}_(k+1), wherein δ:=deg(g_(j1)), {tilde over (B)}_(k) is initialized to 0, (g_(j1))_(m) is a coefficient of X^(m) in g_(j1), result is initialized to 0, and S_(k+1) is a coefficient of the syndrome polynomial; updating result=result·(α_(r) ⁻¹)^(2t); and outputting result. The steps of calculating and storing, for k=2t −δ−1 to 2t−2, {tilde over (B)}_(k+1) and result, updating result and outputting result are performed while adjoining the next weak coordinate α_(r).

According to a further embodiment of the disclosure_(;) the method includes calculating and storing (α_(m) ⁻¹)^(2t) for all weak coordinates α_(m), wherein t=[(d−1)/2] is an error correction radius of a GRS code of designed distance d.

According to another embodiment of the disclosure, there is provided a non-transitory program storage device readable by a computer, tangibly embodying a program of instructions executed by the computer to perform the method steps for fast Chase decoding of generalized Reed-Solomon (GRS) codes.

DESCRIPTION OF THE DRAWINGS

FIG. 1 is a flowchart of Koetter's iterative algorithm for adjoining error locations, according to embodiments of the disclosure.

FIG. 2 is a flowchart of an algorithm for fast chase decoding of generalized Reed-Solomon codes according to embodiments of the disclosure.

FIG. 3 is a block diagram of a system for fast chase decoding of generalized Reed-Solomon codes, according to an embodiment of the disclosure.

FIG. 4 is a flow chart of an algorithm for efficiently calculating g_(j0)(α_(r) ⁻¹) when only g_(j1) is available, according to an embodiment of the disclosure.

DETAILED DESCRIPTION OF EXEMPLARY EMBODIMENTS

Exemplary embodiments of the invention as described herein generally provide systems and methods for performing fast Chase decoding of generalized Reed-Solomon codes. While embodiments are susceptible to various modifications and alternative forms, specific embodiments thereof are shown by way of example in the drawings and will herein be described in detail. It should be understood, however, that there is no intent to limit the invention to the particular forms disclosed, but on the contrary, the invention is to cover all modifications, equivalents, and alternatives falling within the spirit and scope of the invention.

I. Overview

Embodiments of the disclosure use a combination of a syndrome-based hard decision algorithm, such as the Berlekamp-Massey algorithm, and Koetter's algorithm for fast Chase decoding of generalized Reed-Solomon codes, and therefore also for fast Chase decoding of their subfield subcodes. Ira case of bard-decision decoding failure, an algorithm according to an embodiment begins by finding a Groebner basis for the solution module of the key equation. This Groebner basis can be obtained from the existing outputs of the Berlekamp-Massey algorithm, or alternatively, the Euclidean algorithm or Fitzpatrick's algorithm (see P. Fitzpatrick, “On the key equation,” IEEE Trans. Inform. Theory, vol. 41, no. 5, pp. 1290-1302, September 1995, the contents of which are herein incorporated by reference in their entirety, hereinafter Fitzpatrick) may be used. Then, the above Groebner basis is used as an initial value in Koetter's algorithm, as described, e,g., in R. J. McEliece, “The GuruswamiSudan decoding algorithm for Reed-Solomon codes,” IPN Progress Report, vol. 42-153, May 2003, the contents of which are herein incorporated by reference in their entirety. This leads to a tree-based Chase scheduling. Modifying an unmodified coordinate in the received vector amounts to 2 updates in Koetter's algorithm, and does not require updating syndromes. An algorithm according to an embodiment uses the same number of finite-field multiplications per iteration as Wu's algorithm, but it is conceptually simpler.

2. Preliminaries

Let q be a prime power, and let F_(q) be the finite field q elements. Consider a primitive generalized Reed-Solomon (URS) code, C, of length n:=q−1 and designed distance d∈N*, d≥2, where N* is the set of positive integers. Since the most general GRS code can be obtained by shortening a primitive GRS code, there is no loss of generality in considering only primitive GRS codes. In detail, let ã=(ã₀, . . . , ã_(n−1))∈(F*_(q))^(n) be a vector of non-zero elements. For a vector f=(f₀, f₁, . . . , f_(n−1))∈F_(q) ^(n), let f(X):=f₀+f₁X+ . . . +f_(n−1)X^(n−1)∈F_(q)[X]. Now C∈F_(q) ^(n) is defined as the set of all vectors f∈F_(q) ^(n) for which ã(X)⊙f(X) has roots 1, α, . . . , α^(d−2) for some fixed primitive α∈

_(q), where (-⊙-) stands for coefficient-wise multiplication of polynomials: for f(X)=Σ_(i=0) ^(r)f_(i)X^(i) and g(X)=Σ_(i=0) ^(s)g_(i)X^(i), let m:=min[r, s}, and define f(X)⊙g(X):=Σ_(i=0) ^(m)f_(i)g_(i)X^(i).

To recall the key equation, suppose that a codeword x∈C is transmitted, and the received word is y:=x+e for some error vector e∈F_(q) ^(n). For j∈{0, . . . , d−2}, let S_(j)=S_(j) ^((y)):=(ã⊙y)(α_(j)). The syndrome polynomial associated with y is S^((y))(X):=S₀+S₁X+ . . . +S_(d−2)X^(d−2). By the definition of the GRS code, the same syndrome polynomial is associated with e.

If v∈F_(q) ^(n) is such that v(X)=X^(i) for some i∈{0, . . . , n−1}, then S_(j) ^((v))=(ã⊙v)(α^(j))=ã_(i)(α^(i))^(j), so that

${{S^{(v)}(X)} = {{{\overset{\sim}{a}}_{i}\left( {1 + {\alpha^{i}X} + \ldots + {\left( \alpha^{i} \right)^{d - 2}X^{d - 2}}} \right)} \equiv {\frac{{\overset{\sim}{a}}_{i}}{1 - {\alpha^{i}X}}{{mod}\left( X^{d - 1} \right)}}}},$

So, if the error locators are some distinct elements α₁, . . . , α_(ε)∈

*_(q), where ε∈{1, . . . , n} is the number of errors, and the corresponding error values are β₁, . . . , β_(ε)∈

*_(q), then

$\begin{matrix} {{{S^{(y)}(X)} \equiv {\sum\limits_{i = 1}^{ɛ}\; {\frac{\beta_{i}a_{i}}{1 - {\alpha_{i}X}}{{mod}\left( X^{d - 1} \right)}}}},} & (1) \end{matrix}$

where α_(i):=ã_(i), for thei′∈{0, . . . , n−1} with α_(i)=α^(i)′.

Defining the error locator polynomial, σ(X)∈F_(q)[X], by

σ(X):=Π_(i=1) ^(ε)(1−α_(i) X),

and the error evaluator polynomial, ω(X)∈F_(q)[X , by

ω(X):=Σ_(i=1) ^(ε)α_(i)β_(i)Π_(j≠i)(1−α_(j) X),

it follows from EQ. (1) that

ω≡S^((y))σmod(X^(d−1)).   (2)

EQ. (2) is the so-called key equation.

Let

M ₀ =M ₀(S ^((y)):={(u,v)∈F_(q) [X] ² |u≡S ^((y)) v mod(X ^(d−1))}.

be the solution module of the key equation. Next, recall that if the number of errors in y is up to t:=└(d−1)/2┘, then (ω, σ) is a minimal element in M₀ for an appropriate monomial ordering on F_(q)[X]², in fact, it is the unique minimal element (u, v)∈M₀ with v(0)=1—see ahead for details. The monomial ordering of the following definition is the special case of the ordering <_(r) corresponding to r=−1 of Fitzpatrick. If a pair (f(X), g(X)) is regarded as the bivariate polynomial f(X)+Yg(X), then this ordering is also the (1, −1)-weighted-lex ordering with Y>X

-   Definition 2.1: Define the following monomial ordering, <, on     F_(q)[X]²:

(X ^(i)0)<(X^(i), 0) iff i<j; (0, X ^(i))<(0, X ^(j)) iff i<j; (X^(i), 0)<(0, X ^(i)) iff i≤j−1.

The following proposition is a special case of Thm. 3.2 of Fitzpatrick. Its proof is included herein for completeness. Unless noted otherwise, LM(u, v) will stand for the leading monomial of (u, v) with respect to the above monomial ordering, <, and a “Groebner basis” will stand for a Groebner basis with respect to <. Note that in the following proposition, d_(H)(y, x) represents the Hamming distance between vectors y and x.

-   Proposition 2.2: Using the above notation, suppose that d_(H)(y,     x)≤t. Let (u, v)∈M₀(S^((y)))\{(0, 0) satisfy LM(u, v)≤LM(ω, σ). Then     there exists some scalar c∈F*_(q) such that (u, v)=c·(ω,σ)=(c·ω(X),     c·σ(X)). Hence, (ω, σ) is the unique minimal element (u, v) in M₀     with v(1)=1. -   Proof. First, note that if there exist (ũ, {tilde over (v)}), (u,     v)∈M₀(S^((y))) and d₁, d₂∈N with d₁+d₂<d−1, gcd(ũ, {tilde over     (v)})=1, deg(u), deg(ũ)≤d₁, and deg(v), deg({tilde over (v)})≤d₂,     then there exists a polynomial f∈F_(q)[X] such that (u, v)=f·(ũ,     {tilde over (v)}). To see this, note that from u≡S^((y))v mod     (X^(d−1)) and ũ≡S^((y)){tilde over (v)}mod(X^(d−1)), it follows that     u{tilde over (v)}=ũv mod(X^(d−1)). In view of the above degree     constraints, the last congruence implies u{tilde over (v)}=ũx. Since     gcd(ũ, {tilde over (v)})=1, it follows that ũ|u, {tilde over (v)}|v,     and u/ũ=v/{tilde over (v)}. This establishes the claim,

Now let (u, v)∈M₀(S^((y))), and note that gcd(ω, σ) −1. If deg(v)>t≥deg(σ), then clearly LM(u, v)>LM(ω, σ)=(0, X^(deg(σ))). Similarly, if deg(u)>t−1≤deg(σ)−1, then LM(u, v)>LM(ω, σ). Hence, it may be assumed without loss of generality that deg(v)≤t and deg(u)≤t−1. The above claim then shows that (u, v)=f·(ω, σ) for some, FÅF_(q)[X]. If LM(u, v)≤LM(ω, σ), this must imply that f is a constant, as required. This also shows that LM(u, v)=LM(ω, σ).

It will also be useful to recall that the uniqueness in the previous proposition is an instance of a more general result:

-   Proposition 2.3: For a field K and for l∈N*, let < be any monomial     ordering on K[X]^(l), and let M⊂K[X]^(l) be any K[X]-submodule.     Suppose that both f:=(f₁(X), . . . , f_(l)(X))∈M\{0} and g:=(g₁(X),     . . . , g_(l)(X))∈M\{0} have the minimal leading monomial in M\{0}.     Then there exists a c∈K* such that f=c·g. -   Proof Suppose not. Since LM(f)=LM(g), there exists a constant c∈K*     such that the leading monomial cancels in h:=f−cg. By assumption,     h≠0, and LM(h)<LM(f), which is a contradiction.

3 Main Result

An observation according to an embodiment is that the LFSR minimization task Arad, disclosed on page 112 of Wu2012, incorporated above, does not define a module, and can be replaced by a module minimization task. The possibility of using Koetter's algorithm as an alternative to Wu's method follows almost immediately from the following theorem.

-   Theorem 3.1: For r∈N, r≤n, for distinct α₁, . . . , α_(r)∈F*_(q),     and for β₁, . . , β_(r)∈F*_(q), let

M _(r) =M _(r)(S ^((y)), α₁, . . . , α_(r), β₁, . . . , β_(r))

be the set of all pairs (u, v)∈F_(q)[X]² satisfying the following conditions:

-   1. u≡S^((y))vmod(X^(j−1)) -   2. ∀j∈{1, . . . , r}, v(α_(j) ⁻¹)=0 and β_(j)α_(j)v′(α_(j)     ⁻¹)=−α_(j)u(α_(j) ⁻¹) with α_(j):=ã_(j), for the j′ with     α_(j)=α_(j′).

Then

-   1. M_(r) is a K[X]-module. -   2. If d_(H)(y, x)=t+r, α_(j), . . . , α_(r) are error locations and     β₁, . . . , β_(r) are the corresponding error values, then     LW(ω,σ)=min {LM(u, v)|(u, v)∈M_(r)\{0}. -   Proof 1. Clearly, M_(r) is an F_(q)-vector space. For f(X)∈F_(q)[X]     and (u, v) ∈M_(r), it needs to be shown that f·(u, v)∈M_(r).     Clearly, (fu, fv) satisfies the required congruence, and also fv has     the required roots. It remains to verify that for all j,     β_(j)α_(j)(fv)′(α_(j) ⁻¹)=α_(j)(fu)(α_(j) ⁻¹). Now,

${{({fv})^{\prime}\left( \alpha_{j}^{- 1} \right)} = {{{\left( {f^{\prime}v} \right)\left( \alpha_{j}^{- 1} \right)} + {\left( {fv}^{\prime} \right)\left( \alpha_{j}^{- 1} \right)}} = {{\left( {fv}^{\prime} \right)\left( \alpha_{j}^{- 1} \right)} = {{{{f\left( \alpha_{j}^{- 1} \right)} \cdot \frac{- \alpha_{j}}{\beta_{j}a_{j}}}{u\left( \alpha_{j}^{- 1} \right)}} = {{- \frac{\alpha_{j}}{\beta_{j}a_{j}}}({fu})\left( \alpha_{j}^{- 1} \right)}}}}},,$

where in the second equation v(α_(j) ⁻¹)=0 was used, and in the third equation β_(j)α_(j)v′(α_(j) ⁻¹)=α_(j)u(α_(j) ⁻¹) was used (note that β_(j)α_(j)≠0).

2. The proof is by induction on r. For r=0, the assertion is just Proposition 2.2, Suppose that r≥1, and the assertion holds for r−1. Let {tilde over (y)} be obtained from y by subtracting β_(r) from coordinate α_(r). Let {tilde over (σ)}:=σ/(1−α_(r)X), the error locator for {tilde over (y)}, and let {tilde over (ω)} be the error evaluator for {tilde over (y)}. By the induction hypothesis,

LM({tilde over (ω)}, {tilde over (σ)})=min {LM(u, v)|(u, v)∈M_(r−1)}  (3)

with

M _(r−1) :=M _(r−1)(S ^(({tilde over (y)})), α₁, . . . , α_(r−1), β₁, . . . , β_(r−1)).

The following lemma will be useful,

-   Lemma: For (u, v)∈M_(r), write {tilde over (v)}:=v/(1−α,X) and put     h:=u−β_(r)α_(r) {tilde over (v)}. Then (1−α_(r),X)|h(X). Moreover,     writing {tilde over (h)}:=h/(1−α_(r)X), the map ψ: (u, v)→({tilde     over (h)}, {tilde over (v)}) maps M_(r) into M_(r−1), and satisfies     ψ(ω,σ)=({tilde over (ω)}, {tilde over (σ)}). -   Proof of Lemma. Since v=(1−α_(r)X) {tilde over (v)}, we get     v′=−α_(r){tilde over (v)}+(1−α_(r)X){tilde over (v)}′, and therefore     v′(α_(r) ⁻¹)=−α_(r){tilde over (v)}(α_(r) ⁻¹). Hence,

${{h\left( \alpha_{r}^{- 1} \right)} = {{{u\left( \alpha_{r}^{- 1} \right)} - {\beta_{r}a_{r}{\overset{\sim}{v}\left( \alpha_{r}^{- 1} \right)}}} = {{{{- \frac{\beta_{r}a_{r}}{\alpha_{r}}}{v^{\prime}\left( \alpha_{r}^{- 1} \right)}} - {\beta_{r}a_{r}{\overset{\sim}{v}\left( \alpha_{r}^{- 1} \right)}}} = 0}}},$

which proves the first assertion.

For the second assertion, note first that

${S^{(\overset{\sim}{y})} \equiv {S^{(y)} - {\frac{\beta_{r}a_{r}}{1 - {\alpha_{r}X}}{mod}\; \left( X^{d - 1} \right)}}},$

and therefore

${{{S^{(\overset{\sim}{y})}\overset{\sim}{v}} \equiv {{S^{(y)}\overset{\sim}{v}} - {\frac{\beta_{r}a_{r}}{1 - {\alpha_{r}X}}\overset{\sim}{v}}}} = {{{\frac{1}{1 - {\alpha_{r}X}}\left( {{S^{(y)}v} - {\beta_{r}a_{r}\overset{\sim}{v}}} \right)} \equiv {\frac{1}{1 - {\alpha_{r}X}}\left( {u - {\beta_{r}a_{r}\overset{\sim}{v}}} \right)}} = \overset{\sim}{h}}},$

where “≡” stands for congruence modulo X^(d−1), which implies that ({tilde over (h)}, {tilde over (v)}) satisfies the required congruence relation in the definition of M_(r−1). Also, clearly {tilde over (v)}(α_(j) ⁻¹)=0 for all j∈{1, . . . , r−1}. Finally, using v′=α_(r){tilde over (v)}+(1−α_(r)X){tilde over (v)}′ again, it can be seen that for all j∈{1, . . . , r−1},

${{\overset{\sim}{v}}^{\prime}\left( \alpha_{j}^{- 1} \right)} = {\frac{v^{\prime}\left( \alpha_{j}^{- 1} \right)}{1 - {\alpha_{r}\alpha_{j}^{- 1}}} = {{\frac{\alpha_{j}}{\beta_{j}a_{j}} \cdot \frac{u\left( \alpha_{j}^{- 1} \right)}{1 - {\alpha_{r}\alpha_{j}^{- 1}}}} = {\frac{\alpha_{j}}{\beta_{j}a_{j}} \cdot {{\overset{\sim}{h}\left( \alpha_{j}^{- 1} \right)}.}}}}$

This proves that ψ maps M_(r) into M_(r−1).

Finally, ψ(ω, σ)=({tilde over (h)}, {tilde over (σ)}) with {tilde over (h)}=(ω−β_(r)α_(r){tilde over (σ)})/(1−α_(r)X), and it is straightforward to verify that {tilde over (h)}={tilde over (ω)}. In detail, for ε:=t+r, let α′₁, . . . , α′_(ε)F*_(q) be some enumeration of the error locators, let β′₁, . . . , β′_(ε)εF*_(q) be the corresponding error values, and let α′₁, . . . , α′_(ε) be the corresponding entries of the vector it {tilde over (α)}. Assume without loss of generality that α′_(ε)=α_(r), and hence β′_(ε)=β_(r). It follows that

$\begin{matrix} {\overset{\sim}{h} = \frac{\omega - {\beta_{r}a_{r}\overset{\sim}{\sigma}}}{1 - {\alpha_{r}X}}} \\ {= {\frac{1}{1 - {\alpha_{ɛ}^{\prime}X}}\left( {{\sum_{i = 1}^{ɛ}{\beta_{i}^{\prime}a_{i}^{\prime}{\prod_{{j = 1},{j \neq i}}^{ɛ}\left( {1 - {\alpha_{j}^{\prime}X}} \right)}}} - {\beta_{ɛ}^{\prime}a_{ɛ}^{\prime}{\prod_{j = 1}^{ɛ - 1}\left( {1 - {\alpha_{j}^{\prime}X}} \right)}}} \right)}} \\ {= {\frac{1}{1 - {\alpha_{ɛ}^{\prime}X}}\left( {\sum_{i = 1}^{ɛ - 1}{\beta_{i}^{\prime}a_{i}^{\prime}{\prod_{{j = 1},{j \neq 1}}^{ɛ}\left( {1 - {\alpha_{j}^{\prime}X}} \right)}}} \right)}} \\ {= {{\sum_{i = 1}^{ɛ - 1}{\beta_{i}^{\prime}a_{i}^{\prime}{\prod_{{j = 1},{j \neq 1}}^{ɛ - 1}\left( {1 - {\alpha_{j}^{\prime}X}} \right)}}} = {\overset{\sim}{\omega}.}}} \end{matrix}$

This concludes the proof of the lemma.

Returning to the proof of the theorem, if (u, v)∈M_(r) and v=c·σ for some c∈F*_(q), then LM(u, v)≥(0, X^(deg(σ)))=LM(ω, σ). Let (u, v)∈M_(r)\{0} be such that v≠cσ for all c∈F*_(q)F. Then, ψ(u, v)≠c({tilde over (ω)}, {tilde over (σ)}) for all cÅF*_(q), and hence

LM(ψ(u, v))>LM({tilde over (ω)}, {tilde over (σ)})=(0, X ^(deg(σ)−1)),   (4)

where the inequality can be obtained by the induction hypothesis and Proposition 2.3. If the leading monomial of ψ(u, v) is of the form (0, X^(j)) for some j, then LM(ψ(u, v))=(0, X^(deg(v)−1)), and EQ. (4) implies deg(v)>deg(σ), so that certainly LM(u, v)>LM(Ω, σ).

Suppose therefore that LM(ψ(u, v)) is of the form (X^(j), 0) for some j, that is, LM(ψ(u v))=(X^(deg(h)−1), 0). In this case, EQ. (4) implies that deg(h)−1>deg(σ)−2, that is, deg(h)≥deg(σ). But since h=u−β_(r)α_(r){tilde over (v)}, this implies that at least one of u and {tilde over (v)} must have a degree that is at least as large as deg(σ). Now, if deg(u)≥deg(σ), that is, if deg(u)>deg(σ)−1, then LM(u, v)>LM(ω, σ)=(0, X^(degr(σ)))). Similarly, if deg({tilde over (v)})≥deg(σ), then deg(v)>deg(σ), and again LM(u, v)>LM(ω, σ). This completes the proof.

Using the terminology of Theorem 3.1, for a pair (u(X), v(X)∈M_(r−1), embodiments define the r-th root condition on (u,v) as v(α_(r) ⁻¹)=0, so that the root condition on (u,v) involves only v, and the r-th derivative condition as β_(r)α_(r)v′(α_(r) ⁻¹)=−α_(r)u(α_(r) ⁻¹). The above pair (u,v) is in M_(r)⊂M_(r−1)iff it satisfies both the r-th root condition and the r-th derivative condition. When moving from M_(j) to M_(j+1), two additional functionals are zeroed. It was already proved in the theorem that each M_(j) is a K[X]-module. Also, the intersection of M_(j) with the set of pairs (u, v) for which v(α_(j+1) ⁻¹)=0 is clearly a K[X]-module. Hence, if each “root condition” comes before the corresponding “derivative condition,” two iterations of Koetter's algorithm can be used to move from a Groebner basis for to a Groebner basis for M_(j+1).

-   Remark: Note that for all r, M_(r) is free of rank 2. First, since     M_(r) is a submodule of K[X]², it is free of rank at most 2, a     submodule of a free module over a principle ideal domain. Also,     since both (X^(d−1)(1−α_(j)X) . . . (1−α_(r)X), 0) and (ω, σ) are in     M_(r), the rank is at least 2.

4 Koetter's Iterations for Chase Updates

A description of Koetter's iteration is presented in Appendix, below. Using the terminology of the appendix, in the current context l=1, and, as already mentioned, there are two types of Koetter iterations: one for a root condition, and the other for a derivative condition. For a fair comparison with Algorithm 1 of Wu2012, the version of Koetter's iteration presented herein does include inversions, in this version, the right-hand sides of the update rules are both divided by Δ_(j*). Recall that multiplication of elements by non-zero constants takes a Groebner basis to a Groebner basis.

In the r-th root iteration, the linear functional D acts on a pair (u, v) as D(u, v)=v(α_(r) ⁻¹), and hence on X·(u, v) as D(X·(u, v))=α_(r) ⁻¹ D(u, v). In the r-th derivative iteration, which comes after the r-th root iteration,

D(u, v)=β_(r)α_(r) v′(α_(r) ⁻¹)+α_(r) u(α_(r) ⁻¹),

and therefore also

$\begin{matrix} {{D\left( {X \cdot \left( {u,v} \right)} \right)} = {{\beta_{r}{a_{r}({Xv})}^{\prime}\left( \alpha_{r}^{- 1} \right)} + {{a_{r}({Xu})}\left( \alpha_{r}^{- 1} \right)}}} \\ {{= {{{\beta_{r}a_{r}\alpha_{r}^{- 1}{v^{\prime}\left( \alpha_{r}^{- 1} \right)}} + {u\left( \alpha_{r}^{- 1} \right)}} = {\alpha_{r}^{- 1}{D\left( {u,v} \right)}}}},} \end{matrix}$

where (Xv)′=Xv′+v was used in the second equality and v(α_(r) ⁻¹)=0. So, for both types of iterations, root condition and derivative condition, D(X·(u, v))/D(u, v)=α_(r) ⁻¹ if D(u, v)≠0. Hence, the iteration corresponding to a single location α_(r) has the following form.

Algorithm A: Koetter's Iteration for Adjoining Error Location α_(r):

FIG. 1 is a flowchart of Koetter's iterative algorithm for adjoining error locations, according to embodiments of the disclosure.

-   Input: A Groebner basis G={g (g₀₀, g₀₁), g₁=(g₁₀, g₁₁)} for     M_(r−1)(S^((y)), α₁, . . . , α_(r−1), β₁, . . . , β_(r−1)), with     LM(g_(j)) containing the j-th unit vector for j∈{0, 1}

The next error location, α_(r), and the corresponding error value, β_(r).

-   Output: A Groebner basis G⁺{g⁺ ₀=(g⁺ ₀₀, g⁺ ₀₁)), (g⁺ ₁₀, g⁺ ₁₁)}     for M_(r)(S^((y)), α_(j), . . . , α_(r), β_(j), . . . , β_(r)) with     LM(g⁺ _(j)) containing the j-th unit vector for j∈{0, 1}     Algorithm, with references to the flowchart of FIG. 1:

Initialize stop := true // Step 101 For type = root, der // Step 103  If type = der Then // Step 105   For j = 0, 1, set g_(j) := g_(j) ⁺ // initiate with output of root step  For j = 0, 1, calculate // Step 107    $\Delta_{j}:=\left\{ \begin{matrix} {g_{j\; 1}\left( \alpha_{r}^{- 1} \right)} & {{{if}\mspace{14mu} {type}} = {root}} \\ {{\beta_{r}a_{r}{g_{j\; 1}^{\prime}\left( \alpha_{r}^{- 1} \right)}} + {\alpha_{r}{g_{j\; 0}\left( \alpha_{r}^{- 1} \right)}}} & {{{if}{\mspace{11mu} \;}{type}} = {der}} \end{matrix} \right.$ stop := stop and (Δ₁ == 0)) // Step 109 if type == der and stop == true, exit // Step 111, stopping criteria, described below Set J := {j ∈ {0, 1}|Δ_(j) ≠ 0} // Step 113 If J = ϕ Then // Step 115  For j = 0, 1, set g⁺ _(j) := g_(j) // Step 117  Exit and process next error pattern Let j* ∈ J be such that LM(g_(j*)) = min_(j∈J){LM(g_(j))} // Step 119 For j ∈ J // Step 121  If ≠ j* Then    ${{Set}\mspace{14mu} g_{j}^{+}}:={g_{j} - {\frac{\Delta_{j}}{\Delta_{j*}}g_{j*}}}$  Else // j = j*   Set g⁺ _(j) := (X − α_(r) ⁻¹)g_(j*)

Regarding the j≠j* part of step 121, note that multiplication by a non-zero constant is possible in other embodiments. For example, an update of the form g⁺ _(j)=Δ_(j*)g_(j)−Δ_(j)g_(j*) is also allowed.

It should be noted that multiplying all elements of a Groebner basis by (possibly different) non-zero constants results in a Groebner basis. Hence, multiplying the outputs of Algorithm A by non-zero constants again gives a Groehner basis with the required properties. Moreover, in Algorithm A, if each update of the form

$g_{j}^{+}:={g_{j} - {\frac{\Delta_{j}}{\Delta_{j^{*}}}g_{j*}}}$

or g⁺ _(j*):=(X−α_(r) ⁻¹)g_(j*) is replaced by

$g_{j}^{+}:={c\left( {g_{j} - {\frac{\Delta_{j}}{\Delta_{j^{*}}}g_{j*}}} \right)}$

or g⁺ _(j*):=c′(X−α_(r) ⁻¹)g_(j*), respectively, where c, c′ are non-zero constants that may depend on j, then the output will still he a Groebner basis with the required properties.

A stopping criterion for a Koetter algorithm according to an embodiment for fast Chase decoding, implemented as steps 101, 109, and 111, is as follows. Suppose that (α₁, β₁), . . . , (α_(r), β_(r)) are correct pairs of error locations and corresponding error values, and that, as above, r=ε−t, so that an error-locator polynomial is, up to non-zero multiplicative constant, the second coordinate of the output g⁺ ₁ of the derivative step of Koetter's iteration for adjoining error-locator α_(r). However, it is expensive to perform a Chien search. However, suppose there exists one more erroneous location, α_(r+1), within the weak coordinates, with corresponding error value is β_(r+1). Then, according to embodiments of the disclosure, in Koetter's iteration for adjoining the pair (α_(r+1), β_(r+1)) to (α₁, β₁), . . . , (α_(r), β_(r)). Δ₁=0 for both the root step and the derivative step. For the root step, this follows from the fact that α_(r+1) ⁻¹ is a root of the ELP σ(X), and for the derivative step it follows from the fact that ω(X), σ(X) satisfy Forney's formula. Thus, checking if Δ₁=0 for both the root step and the derivative step can serve as a stopping criterion. However, it is possible that Δ₁=0 for both the root step and the derivative step even if there is not a correct error-locator polynomial, i.e., a false positive. The cost of handling a false positive is an increased complexity. However, even if the false positive rate is of the order 1/100, or even 1/10, the overall increase in complexity is negligible, and a Monte Carlo simulation can be used to obtain a reliable estimation in such situations. The cost of a stopping criterion according to an embodiment involves performing one more root step and half a derivative step for the discrepancy calculations for a sphere of radius r+1 when ε−t is only r. This reduces the overall complexity gain over a brute force Chien search. When ε−t=r, r+1 errors are needed in the weak coordinates, which slightly degrades the FER in comparison to a brute force Chien search. It is to be understood that the implementation of a stopping criteria according to an embodiment in steps 101, 109, and 111 is exemplary and non-limiting, and other embodiments of the disclosure can use different implementations to achieve a same result.

Next, according to an embodiment, consider some simplifications. The above scheme has two pairs of polynomials to be maintained, rather than just two polynomials. In the above form, the algorithm will work even if ε≥2t, where e is the total number of errors. It should be noted that Wu's fast Chase algorithm does not have a version that supports more than 2t−1. errors. However, if ε≤2t−1, as supported by Wu's algorithm, there is no need to maintain the first coordinate of the Groebner basis. For this, two questions should be answered:

-   -   1. How can g_(j0)(α_(r) ⁻¹) be calculated efficiently when only         g_(j1) is available?     -   2. How can LM(g₀) be found without maintaining g₀₀ (recall that         the leading monomial of g₀ is on the left)?

To answer the second question: introduce a variable d₀ to track the degree of g₀₀. Whenever j*=0, increase d₀ by 1, and in all other cases keep d₀ unchanged. Note that when 0∈J but 0≠j*, LM(g⁺ ₀)=LM(g₀), as shown in Appendix A, which justifies keeping d₀ unchanged.

Recalling that the algorithm of FIG. 1 is invoked for any adjoined weak coordinate down the path front the root to a leaf, with the previous g₁ ⁺ becoming the next g₁, an implementation according to an embodiment of this answer would involve initializing d₀=deg(g₀₀) in the root of the tree, before any invocation of the algorithm of FIG. 1. In the process of executing the tree traversal, the d₀ should be saved on vertices with more than one child and used as an initialization for all paths going down from that vertex to a leaf. A step of defining: LM(g₀)=(X^(d) ⁰ , 0) would he performed after step 105, and an update step, if j*=0 then ++d₀, would be performed after step 119. Note that, in going down a path to a leaf, d₀ from a previous application of the algorithm of FIG. 1 should he used as an initial value for the next application of the algorithm.

Turning to the first question, it is known that for all r and all (u, v)∈M_(r)(S^((y)), α₁, . . . , α_(r), β₁, . . . , β_(r)), then u≡S^((y))v mod (X^(2t)), and hence one can calculate u(αhd r⁻¹) directly from v if deg(u)≤2t−1 (see ahead). So, a first task is to verify that if ε≤2t−1, so that r≤2t−1−t=t−1, then deg(g₁₀)≤2t−1 and deg(g₂₀)≤2t−1. for all Koetter's iterations involved in fast Chase decoding, assuming the hypotheses of Theorem 3.1 hold.

First, however, recall the following proposition, which is just a re-phrasing of Prop. 2. of Beelen, et al., “On Rational Interpolation-Based List-Decoding And List-Decoding Binary Goppa Codes”, IEEE Trans. Inform. Theory, Vol. 59, No. 6, pp. 3269-3281, June 2013 the contents of which are herein incorporated by reference in their entirety. For the sake of completeness, a proof is included in Appendix B. From this point on, a monomial in K[X]² will he said to be on the left if it contains the unit vector (1, 0), and on the right if it contains the unit vector (0, 1).

-   Proposition 4.1: Let {h₀=(h₀₀, h₀₁), h₁=(h₁₀, h₁₁)} be a Groebner     basis for M₀ with respect to the monomial ordering <, and suppose     that the leading monomial of h₀ is on the left, while the leading     monomial of h₁ is on the right. Then deg(h₀₀(X))+deg(h₁₁(X))=2t.

With Proposition 4.1, it can be proven that for all iterations of Koetter's algorithm, deg(gr₁₀)<2t−1 and deg(g₂₀)≤2t −1 when ε≤2t−1. Before the proof, it will be useful to introduce some additional notation.

Definition 4.2: For i=1, . . . , r, j∈{0, 1}, and T∈{root, der} write g_(j)(i; T)=(g_(j0)(i; T), g_(j1)(i; T)) and g⁺ _(j)(i; T)=(g⁺ _(j0)(i; T), g⁺ _(j1)(i: T)) for the values in the root step (T=root) or the derivative step (T=der) of Algorithm A corresponding to adjoining error location α_(j). Explicitly, the notation g₀(i; root) and g_(t)(i; root) are the values of the input variables g₀ and g₁ respectively, during the root iteration of the application of algorithm A for adjoining α_(i). Similarly, g₀(i; der) and g₁(i; der) are the values of the input variables g₀ and g₁, respectively, during the derivative iteration of the application of algorithm A for adjoining α_(i). By convention, {g₀(1; root), g₁(1; root)} is a Groebner basis for M₀ with LM(g₀(1; root)) on the left and LM(g₁(1; root)) on the right.

-   Proposition 4.3: Suppose that the condition in part 2 of Theorem 3.1     holds. Then for all i∈{1, . . . , r}, all jÅ{0, 1} and all T∈{root,     der}, deg(g_(j0)(i; T))≤ε and deg(g_(j1)(i; T))≤ε, where ε=t+r is     the total number of errors. -   Proof. By Theorem 3.1, (ω, σ)=c·g⁺ _(j)(r; der) for some j∈{0, 1}     and some c∈F*_(q), and hence necessarily (ω, σ)=c·g⁺ ₁(r; der) for     some c∈F*_(q), as the leading monomial of (ω, σ) is on the right.     Note that for all i, j, and T, LM(g⁺ _(j)(i; T))≥LM(g_(j)(i; T)) is     true, and so for all i and T, LM(g₁(i; T))≤LM(ω, σ)=(0, X^(c)) must     be true, in particular, deg(g₁₀(i; T))≤ε−1, and deg(g₁₁(i; T))≤ε.

Turning to g₀(i; T), note that for all i, j, and T, LM(g⁺ _(j)(i; T))>LM(g_(j)(i; T)) for at most one j∈{0, 1}. Also, for j∈{0, 1} and for each i and T with LM(g⁺ _(j) (i; T))>LM(g_(j)(i; T)), LM(g⁺ _(j)(i; T))=X LM(g_(j)(i; T)) is true. Since the degree of the second coordinate of g_(j)(i; T), the coordinate containing the leading monomial, must increase from deg(g₁₁(1; root)) for i=1 and T=root to deg(σ)=ε for i=r and T=der, it follows that

|{(i, T)|LM(g ⁺ ₁(i; T))>LM(g ₁(i; T))}|=ε−deg(g ₁₁(1; root)),

and therefore,

|{(i, T)|LM(g₀⁺(i;  T)) > LM(g₀(i;  T))}| ≤ 2 r − (ɛ − deg (g₁₁(1;  root))) = deg (g₁₁(1;  root)) + r − t.

Hence, for all i and T,

$\begin{matrix} {{\deg \left( {g_{00}\left( {i\text{;}\mspace{14mu} T} \right)} \right)} \leq {{\deg \left( {g_{00}\left( {r\text{;}\mspace{14mu} {der}} \right)} \right)}\left( {{{LM}\left( {{on}\mspace{14mu} {the}\mspace{14mu} {left}} \right)}{does}\mspace{14mu} {not}\mspace{14mu} {decrease}} \right)}} \\ {\leq {{\deg \left( {g_{00}\left( {1\text{;}\mspace{14mu} {root}} \right)} \right)} + {\deg \left( {g_{11}\left( {1\text{;}\mspace{14mu} {root}} \right)} \right)} + r - t}} \\ {= {{t + r} = {ɛ\mspace{14mu} {\left( {{by}\mspace{14mu} {Proposition}\mspace{14mu} 4.1} \right).}}}} \end{matrix}$

Finally, since the leading monomial of g₀(i; T) is on the left, it follows that deg(g₀₁(i; T)) −1<deg(g₀₀(i; T)≤ε, which proves deg(g₀₁(i; T))≤ε.

Using Proposition 4.3, g_(j0)(α_(r) ⁻¹) can be calculated in Algorithm A while maintaining only the right polynomials g_(j1)(j∈{0, 1}). According to embodiments of the disclosure, an efficient O(t) method for calculating g₁₀(α_(r) ⁻¹is as follows.

For a polynomial v(X)∈K[X], assume that δ:=deg(v)≤ε≤2t−1, and write v(X)=v₀+v₁X+ . . . +v_(2t−1)X^(2t−1). For short, write S(X)=S₀+S₁X+ . . . +S_(2t−1)X^(2t−1):=S^((y))(x). Then for β∈F_(q), (Sv mod(X^(2t))) (β) can he expressed as

S ₀ v ₀+(S ₀ v ₁ +S ₁ v ₀)β+(S ₀ v ₂ +S ₁ v ₁ +S ₂ v ₀)β²+ . . . (S ₀ v _(2t−1) +S ₁ v _(2t−2) +S ₂ v _(2t−3) + . . . +S _(2t−1) v ₀)β^(2t−1),   (5)

For j∈{0, . . . , 2t−1}, let A_(j)(v, β) be the sum over the j-th column of EQ. (5). Then

A _(j)(v, β)=S _(j)β^(j)(v ₀ +v ₁ β+ . . . +v _(2t−1−j)β^(2t−1−j)),

If 2t−1−j≥δ(=deg(v)), then A_(j)(v, β)=S_(j)β^(f)v(β). Hence if β is a root of v(X), then

(Sv mod(X ^(2t)))(β)=ρ_(j=0) ^(2t−1) A _(j)(v, β)=Σ_(j=2t−δ) ^(2t−1) A _(j)(v, β)   (6)

The sum on the right-hand side of EQ. (6) may be calculated recursively. For this, let

Ã _(j)(v, β):=β^(j)Σ_(i=0) ^(2t−1−j) v _(i)β^(i),

so that A_(j)(v, β)=S_(j)Ã_(j)(v, β). Then Ã_(2t−δ−1)=0, and for all j∈{2t−δ−1, . . . , 2t−2},

$\begin{matrix} {\frac{{\overset{\sim}{A}}_{j + 1}\left( {\upsilon,\beta} \right)}{\beta^{2\; t}} = {{\beta \cdot \frac{{\overset{\sim}{A}}_{j}\left( {\upsilon,\beta} \right)}{\beta^{2\; t}}} - {\upsilon_{{2\; t} - 1 - j}.}}} & (7) \end{matrix}$

Calculating, β^(2t) takes O(log₂(2t)) squarings and multiplications. In fact, this can be calculated once, before starting the depth-first search in Wu's tree, for all non-reliable coordinates, not just for those corresponding to a particular leaf. After that, each one of the iterations of EQ. (7) in the calculation of the sum of EQ. (6 requires 2 finite-field multiplications: two for moving from Ã_(j)(v, β)/β^(2t) to Ã_(j+1)(v, β/β^(2t), and one for multiplying by S_(j+1) before adding to an accumulated sum. Then, after the calculation of the accumulated sum, one additional multiplication by β^(2t) is required.

FIG. 4 is a flow chart of an algorithm for an answer to the first question, according to an embodiment of the disclosure. An algorithm according to an embodiment, with references to the steps of FIG. 4, is as follows.

Before starting an algorithm of FIG. 1:

 Calculate and store (α_(m) ⁻¹)^(2t) for all weak coordinates α_(m) // Step 40 Perform algorithm of FIG. 1 for weak coordinate α_(r−1) //Step 41 When adjoining a next weak coordinate αr, for any choice of the corresponding error value β_(r), if type == der, perform the following steps: //Step 42   ${{{Initialize}\mspace{14mu} {\overset{\sim}{B}}_{{2t} - \delta - 1}} = {0//\mspace{14mu} {{\overset{\sim}{B}}_{j} \equiv \frac{{\overset{\sim}{A}}_{j + 1}\left( {v,\beta} \right)}{\beta^{2\; t}}}}},\; {{{{where}\mspace{14mu} v} = {{g_{j\; 1}\mspace{14mu} {and}\mspace{14mu} \beta} = \alpha_{r}^{- 1}}};}$ Step 43  Initialize resu1t=0  For k = 2t − δ − 1, . . . , 2t − 2, //Step 44   Calculate and store {tilde over (B)}_(k+1) = α_(r) ⁻¹ · {tilde over (B)}_(k) − (g_(j1))_(2t−1−k)    // (g_(j1))_(m) is the coefficient of X^(m) in g_(j1)   Update result = result + S_(k+1){tilde over (B)}_(k+1)    //S_(k+l) is a syndrome polynomial coefficient  Update result = result · (α_(r) ⁻¹)^(2t)   // (α_(r) ⁻¹)^(2t) was pre-calculated once in the first step; Step 45  Output result // result is g_(j0) (α_(r) ⁻¹) for j == 0, 1; Step 46 Return to step 41 and repeat algorithm of FIG. 1 for next weak coordinate, until all weak coordinates have been processed. // Step 47

5. Fast Chase Decoding

FIG. 2 is a flowchart of an algorithm for fast chase decoding of generalized Reed-Solomon codes according to embodiments of the disclosure. As above, consider a primitive generalized Reed-Solomon (GRS) code, C⊂F_(q) ^(n), of length n:=q−1, q be a prime power, and designed distance d∈N*, d≥2, and F_(q) be the finite field of q elements Given a received codeword y=x+e , where X∈C is a transmitted GRS codeword, C is a GRS code, and e is an error vector, a decoding algorithm begins at step 20 by calculating the syndrome polynomial S^((y))(X )from the Channel output y, wherein S^((y))(X):=S₀+S₁X+ . . . +S_(d−2)X^(d−3) and S_(j)=S_(j) ^((y)):=(ã⊙y)(α^(j)), and applying a syndrome-based hard decision algorithm at step 21 to the input S^((y))(X) to find the estimated error-locator polynomial (ELIC) σ(X):=Π_(i=1) ^(ε)(1−α_(i)X). Exemplary syndrome-based hard decision algorithms include, but are not limited to, the Beriekamp-Massey (BM), Fitzpatrick's algorithm and the Euclidean algorithm.

Next, at step 22, check whether the syndrome-based hard decision algorithm succeeded in finding an error vector of weight up to t, where t is the error-correction radius of the GRS code, i.e.,

$t = {\left\lbrack \frac{d - 1}{2} \right\rbrack.}$

If the syndrome-based hard decision algorithm is the BM algorithm, then one way of doing this is to let the output of the BM algorithm be a pairce, ({circumflex over (σ)}, L), where {circumflex over (σ)}={circumflex over (σ)}(X)is the estimated ELP, while L is the LFSR length calculated in the BM algorithm. The decoding is a success if the following condition holds: deg({circumflex over (σ)}(X))=L and {circumflex over (σ)}(X) has L distinct roots in F_(q).

If, at step 28, the HD decoding is successful, let the estimated error locations be the inverses of the roots of the estimated ELP {circumflex over (σ)}(X), calculate the error values, and estimate ê for the error vector from the estimated error locations and error values, and output the estimate {circumflex over (x)}:=y+ê for x.

According to embodiments, error values can be calculated by finding the error evaluator polynomial (EEP) ω(X)ÅF_(q)[X], by ω(X):=Σ_(i=1) ^(ε)α_(i)β_(i)Π_(j≠i)(1−α_(j)X), by substituting {circumflex over (σ)}(X) as the ELP in the key equation ω≡S^((y))σmod (X^(d−1)). According to other embodiments, error values can be calculated using Forney's formula.

Otherwise, if the HD decoding is unsuccessful, the unreliable (“weak”) coordinates and their potential error values are identified at step 24, and an initial Groebner basis G based on the outputs of the syndrome-based hard decision algorithm is found at step 25.

According to embodiment, if the syndrome based hard decision algorithm is the BM algorithm, finding an initial Groebner basis G based on the BM algorithm outputs includes defining b₁:=(Sσ mod X^(d−1), σ), and b₂:=(SX^(m)T mod X^(d−1), X^(m)B), where B is a polynomial output from the BM algorithm that is a copy of the last ELP before L was updated, and outputting one of (1) c{b₁, b₂} as the Groebner basis if the leading monomials of b₁ and b₂ contain distinct unit vectors, where c is a non-zero constant; (2) d{b₁−cX^(l)b₂, b₂} as the Groebner basis if the leading monomials contain the same unit vector and the leading monomial of b₁ is at least as large as that of b2 , where c∈K* and l∈N are chosen such that the leading monomial of b₁ is canceled, and d is a non-zero constant; or (3) {db₁, d(b₂−cX^(l)b₁)} as the Groebner basis if the leading monomials contain the same unit vector and the leading monomial of b₂ is strictly larger than that of b₁, where c∈K* and l∈N* are chosen such that the leading monomial of b₂ is canceled, and d is a non-zero constant.

Next, a subset of all possible error patterns

E_(i₁) × … × E_(i_(n₀)),

on the unreliable coordinates is scanned, where n₀ is the number of unreliable coordinates, and I₁, . . . , i_(n) ₀ are the unreliable coordinates. The subset of error patterns is formed into a tree, where vertices correspond to error patterns and edges connect a “parent” error pattern to a “child” error pattern having exactly one additional non-zero value.

At step 26, traverse the tree of error patterns until Δ₁=0 for both the root and der steps, wherein moving from a vertex corresponding to an error pattern with error locations α₁, . . . , α_(r−1) and corresponding error values β₁, . . . , β_(r−1) to a child with one additional error location α_(r) and corresponding error value β_(r) corresponds to moving from a current Groebner basis G={g₀=(g₀₀, g₀₁), g₁=(g₁₀, g₁₁)} for M_(r−1)(S^((y)), α_(j), . . . , α_(r−1), β₁, . . . , β_(r−1)), with LM(g_(j)) containing the j-th unit vector for j∈{0, 1} to a Groebner basis G⁺={g⁺ ₀=(g⁺ ₀₀, g⁺ ₀₁)), g⁺ ₁=(g⁺ ₁₀, g⁺ ₁₁)} for M_(r)(S^((y)), α₁, . . . , α_(r), β₁, . . , β_(r)) with LM(g⁺ _(j))containing the j-th unit vector for j∈{0, 1}. According to embodiments, Koetter's iteration Algorithm A for adjoining error locations α_(r) can be used to move from the Groebner basis G to the Groehner basis G⁺.

The correct error pattern is reached if there is a total t+r of erroneous coordinates in y, and if α₁, . . . , α_(r) are indeed error locations and β₁, . . . , β_(r) are indeed the corresponding error values, and it is guaranteed that the output g₁ ⁺ of the algorithm satisfies g₁ ⁺=c·(ω, σ) for some non-zero constant c, where ω is the EEP and σ is the ELP. To use a simplified stopping criterion according to an embodiment, the maximum tree depth should be increased by 1, and a Chien search is performed only in case Δ₁=0 for both the root and the derivative iterations. If there is one additional error locator α_(r+1) in the weak coordinates and the set of potential error patterns for coordinate α_(r+1) includes the correct error value β_(r+1) for α_(r+1), then the stopping criterion will succeed.

If, at step 27, a valid estimated error value ê was found, {circumflex over (x)}=y+ê is output at step 28 as an estimate for the transmitted codeword x. Otherwise, at step 29. If no such ê is found, a decoding failure is output.

According to embodiments, the complexity of an algorithm according to an embodiment can be roughly compared with one iteration of Wu's Algorithm 1, pp. 114-115 of Y. Wu, “Fast Chase Decoding Algorithms and Architectures for Reed-Solomon Codes”, IEEE Trans. Inform. Theory, Vol. 58, No. 1, pp. 109-129, January 2012, incorporated by reference above.

In Wu's iteration, there are 2 substitutions in polynomials of degrees typically growing from t to ε, and two calculations of substitutions of the form (Sf mod X^(2t))(x) based on the knowledge of f, using Wu's, EQS. (23) and (24). Each of the last two substitutions takes about 2t multiplications, noting that the internal sums of Wu's, EQS. (23) and (24) were already calculated for the first two substitutions.

In an algorithm according to an embodiment, there are 2 substitutions in polynomials of degrees typically growing from t to ε, two calculations of substitutions of the form (Sf mod X^(2t))(x) based on the knowledge of f using the recursion EQ. (7), each requiring about 2t multiplications, and two substitutions in the derivative g′_(j1), which, in characteristic 2 has non-zero coefficients only for even powers of X.

In a typical application of Wu's algorithm, there are 3 multiplications of a vector by a scalar, where the vector length typically grows from t to ε. On the other hand, in an algorithm according to an embodiment, there are 4 such multiplications, 2 for each one of the root and der steps. However, this advantage of Wu's algorithm is balanced by the following item.

Wies method requires a syndrome update step that updates about t syndrome coordinates with a total of about t multiplications, which is completely avoided in an algorithm according to an embodiment.

Considering the above, the complexity of an algorithm according to an embodiment is somewhat higher than that of Wu's iteration. However, it is conceptually simpler. Also, an algorithm according to an embodiment is suitable for working in the so-called transform domain, using evaluation vectors of both the and the formal derivatives of the g_(j1). Moreover, an algorithm according to an embodiment can work also for the case where the total number of errors is strictly above d−1, by maintaining two pairs of polynomials.

6. System Implementations

It is to be understood that embodiments of the present disclosure can he implemented in various forms of hardware, software, firmware, special purpose processes, or a combination thereof In one embodiment, the present disclosure can be implemented in hardware as an application-specific integrated circuit (ASIC), or as a field programmable gate array (FPGA). In another embodiment, the present disclosure can be implemented in software as an application program tangible embodied on a computer readable program storage device. The application program can be uploaded to, and executed by, a machine comprising any suitable architecture.

FIG. 3 is a block diagram of a system for fast chase decoding of generalized Reed-Solomon codes, according to an embodiment of the disclosure. Referring now to FIG. 3, a computer system 31 for implementing the present invention can comprise, inter alia, a central processing unit (CPU) 32, a memory 33 and an input/output (I/O) interface 34. The computer system 31 is generally coupled through the I/O interface 34 to a display 35 and various input devices 36 such as a mouse and a keyboard. The support circuits can include circuits such as cache, power supplies, clock circuits, and a communication bus. The memory 33 can include random access memory (RAM), read only memory (ROM), disk drive, tape drive, etc., or a combinations thereof. The present disclosure can be implemented as a routine 37 that is stored in memory 33 and executed by the CPU 32 to process the signal from the signal source 38. As such, the computer system 31 is a general purpose computer system that becomes a specific purpose computer system when executing the routine 37 of the present invention. Alternatively, as described above, embodiments of the present disclosure can be implemented as an ASIC or FPGA 37 that is in signal communication with the CPU 32 to process the signal from the signal source 38.

The computer system 31 also includes an operating system and micro instruction code. The various processes and functions described herein can either be part of the micro instruction code or part of the application program (or combination thereof) which is executed via the operating system. In addition, various other peripheral devices can be connected to the computer platform such as an additional data storage device and a printing device.

It is to be further understood that, because some of the constituent system components and method steps depicted in the accompanying figures can be implemented in software, the actual connections between the systems components (or the process steps) may differ depending upon the manner in which the present invention is programmed. Given the teachings of the present invention provided herein, one of ordinary skill in the related art will be able to contemplate these and similar implementations or configurations of the present invention.

While the present invention has been described in detail with reference to exemplary embodiments, those skilled in the art will appreciate that various modifications and substitutions can be made thereto without departing from the spirit and scope of the invention as set forth in the appended claims.

A. Koetter's Algorithm

For completeness, a self-contained presentation of Koetter's algorithm is presented hereinbelow, taken from Sect. VILC of R. J. McEliece, “The Guruswami-Sudan Decoding Algorithm for Reed-Solomon Codes”, IPN Progress Report, Vol. 42-453, May 2003, the contents of which are herein incorporated by reference in their entirety. For convenience, the current presentation of the algorithm is stated in the language of Groebner bases.

Let K be a field. Fork l∈N* and for a K[X]-submodule M of K[X]^(l+1) with rank(M)=l+1, suppose that there is a Groebner basis G=(g₀, . . . , g_(l)} for M with respect to some monomial ordering < on K[X]^(l+1). In such a case, the leading monomials of the g_(i) must contain distinct unit vectors, as otherwise, the leading monomial of two basis vectors would contain the same unit vector, so that the leading monomial of one vector divides the leading monomial of the other vector. In such a case, one of the basis vectors may be discarded which leaves a Groebner basis, which is, in particular, a set of less than l+1 generators for a free module of rank l+1, which is a contradiction. Thus, according to an embodiment, it may be assumed without loss of generality that the leading monomial of g_(j) contains the j-th unit vector, for all j∈{0, . . . , l}, where coordinates of vectors are indexed by 0, . . . , l.

From this point on, according to an embodiment, < will stand for an arbitrary monomial ordering on K[X]^(l+1).

Now let D: K[X]^(l+1)→K be a non-zero linear functional that satisfies the following property:

MOD M⁺ :=M∩ker(D) is a K[X]-module,

Before proceeding, it may he useful to note that, as a consequence of the proof of validity of Koetter's algorithm appearing ahead, it holds that moving from M to M⁺ does not decrease the rank. The purpose of Koetter's algorithm is to convert the (l+1)-element Groebner basis G of M to an (l+1)-element Groebner basis G⁺−{g⁺ ₀, . . . , g⁺ _(l)} of M⁺, while maintaining the property that LM(g⁺ _(j)) contains the f-th unit vector for all j∈{0, . . . , l}. From this point on, “Groebner basis” will mean a Groebner basis with respect to a fixed monomial ordering <.

Now, it can be proved that a single iteration of Koetter's algorithm has the required properties.

Koetter's Iteration without Inversions:

-   Input: A Groebner basis G={g₀, . . . , g_(l)} for the submodule     M⊂F_(q) ^(l+1), with LM(g) containing the j-th unit vector for all     j. -   Output: A Groebner basis G⁺={g⁺ ₀, . . . , g⁺ _(l)} for M⁺ with     LM(g⁺ _(l)) containing the j-th unit vector for all j, assuming MOD     holds. -   Algorithm:

For j = 0, ..., l, calculate Δ_(j) := D(g_(j)) Set J := {j ∈ {0, ..., l}|Δ_(j) ≠ 0 } If J = Ø, Then    For j = 0, ..., l, set g⁺ _(j) := g_(j)    Exit Let j* ∈ J be such that LM(g_(j*)) = min_(j∈J){LM(g_(j))}    /* the leading monomials are distinct, and so j* is unique */ For j ∈ J    If j ≠ j*       Set g⁺ _(j) := Δ_(j*gj) − Δ_(jgj*)    Else /* j = j**/       Set g⁺ _(j*):= Δ_(j )

 Xg_(j*)− D(X g_(j*)) g_(j*)       /* = ( Δ_(j*)X − D(X g_(j*))) g_(j*)*/

indicates data missing or illegible when filed

-   Proposition A.2: At the end of Koetter's iteration, it holds that     G⁺={g⁺ ₀, . . . , g⁺ _(l)} is a Groebner basis for M⁺ and for all j,     LM(g⁺ _(j)) contains the j-th unit vector. -   Proof: First note that by the linearity of D, at the end of     Koetter's iteration, g⁺ _(j)∈M⁺ for all j. It will be proven that     for all j, -   LM(g⁺ _(j))=min {LM(f)|f∈M⁺ and LM(f) contains the j-th unit vector}     This show that, since modules according to embodiments are over     K[X], the leading monomial of every element in M⁺ is divisible by     the leading monomial of some element from G⁺, and hence G⁺ is a     Groebner basis.

For j∈{0, . . . l}, write

-   -   M_(j):={f∈M\{0}|LM(f) contains the j-th unit vector}         and     -   M⁺ _(j):={f∈M⁺\{0}|LM(f) contains the j-th unit vector}.         Note that since M⁺ ⊂M, it also holds that M⁺ _(j) ⊂M_(j) for all         j,

Take some j∈{0, . . . , l}. If j∈J, then since g⁺ _(j)=g_(j) and LM(g_(j)) is minimal in LM(M_(j)) ⊃LM(M⁺ _(j)), then certainly LM(g⁺ _(j)) is minimal in LM(M⁺ _(j)). This minimality follows from the assumptions on a Similarly, if j∈J and j≠j*, then

LM(g ⁺ _(j))=LM(Δ_(j*) g _(j)−Δ_(j) g _(j*))=LM(g _(j)),

and again, LM(g⁺ _(j)) is minimal in LM(M⁺ _(j)).

It remains to verify that if J≠Ø, then LM(g⁺ _(j*))=min(LM(M⁺ _(j*))). Note first that because < is a monomial ordering, LM(Xg_(j*))=X LM(g_(j*)), and X LM(g_(j*))>LM(g_(j*)). Hence, LM(g⁺ _(j*))=X LM(g_(j*)). In addition, X LM(g_(j*)) is the immediate successor of LM(g_(j*)) in LM(M_(j*)).

Suppose that there exists some h_(j*)∈M⁺ _(j*) with LM(h_(j*))<LM(g⁺ _(j*)). It will be proven that this implies an infinite decreasing chain, and hence a contradiction. Because h_(j*) is also in M_(j*), then LM(h_(j*)) must be true, and therefore LM(g_(j*))≤LM(h_(j*))<LM(g⁺ _(j*)). But LM(g′_(j*)) is the immediate successor of LM(g_(j*)) in LM(M_(j*)), and therefore LM(h_(j*))=LM(g_(j*)) must be true.

Let c∈K* be such that LM(g_(j*)−ch_(j*)) is strictly smaller than LM(h_(j*))=LM(g_(j*)) and set δ₀:=g_(j*)−ch_(j*). Note that since g_(j*)∉M⁺ while h_(j*)∈M⁺, then δ₀∉M⁺, and, in particular, δ₀≠=0. Suppose that LM(δ₀) contains the j₀-th unit vector for some j₀∈{0, . . . l}.

If j₀∈J, then LM(δ₀)<LM(g_(j*))≤LM(g_(j0)), where the first inequality follows from the construction of δ₀, and the second from the definition of j*. Since δ₀∈M_(j0), this contradicts the assumption on g_(j0).

It follows that j₀∉J. By the minimality of LM(g_(j0)) in LM(M_(j0)), there exists some d≥0 such that LM(δ₀)=X^(d)LM(g_(j0)). Choose c∈K* such that the leading monomial cancels in δ₁:=δ₀−cX^(d)g_(j0). Note that δ₁∉M⁺, because δ₀∉M⁺, while g_(j0)∈M⁺ since j₀∉J. Then by construction, δ₁≠0, and LM(δ₁)<LM(δ₀)).

Suppose that LM(δ₁) contains the j₁-th unit vector. If j₁∈J, then LM(δ₁)<LM(δ₀)<LM(g_(j*))≤LM(g_(j1)), a contradiction, since δ₁∈M_(j1). Hence j₁∉J. Continuing this way, an infinite strictly decreasing chain can be obtained, which is a contradiction.

B. Proof of Proposition 4.1

Since (S^((y)), 1) is in the F_(q)[X]-span of {h₀, h₁}, it follows that I∈(h₀₁, h₁₁), and hence that h₀₁ and h₁₁ are relatively prime. Now suppose that α(X), β(X)∈F_(q)[X] are such that α(X)h₀−β(X)h₁=(?, 0). Then ═(X)h₀₁(X)=β(X)h₁₁(X), and because gcd(h₀₁, h₁₁)=1, this implies that h₁₁(X)|α(X), h₀₁(X)|β(X),

${\frac{\alpha (X)}{h_{11}(X)} = \frac{\beta (X)}{h_{01}(X)}},$

and these two equal rational functions are in fact a polynomial in F_(q)[X]. Write r(X)∈F_(q)[X] for this polynomial. Let π₀: F_(q)[X]²ΔF_(q)[X] be the projection to the first coordinate. Now, the second coordinate of the vector

f:=h ₁₁(X)h ₀ −h ₀₁(X)h ₁ ∈M ₀

is 0, and for α(X), β(X) as above, it follows from the above explanation that

α(X)h ₀−β(X)h ₁ =r(X)f.

This shows that π₀(f) has the lowest degree in π₀ (M₀∩{(?, 0)}). Now, as M₀ is generated as an F_(q)[X]-module by {(X^(2t), 0), (S^((y))(X), 1)}, this lowest degree is 2t. Hence deg(π₀(f)) 2t. Now,

$\begin{matrix} {{\deg \left( {\pi_{0}(f)} \right)} = {\deg \left( {{{h_{11}(X)}{h_{00}(X)}} - {{h_{01}(X)}{h_{10}(X)}}} \right)}} \\ {{= {\deg \left( {{h_{11}(X)}{h_{00}(X)}} \right)}},} \end{matrix}$

because by assumption deg(h₁₁)≥deg(h₁₀)+1 and deg(h₀₀)>deg(h₀₁)−1, so that

deg(h ₁₁ h ₀₀)>deg(h ₀₁ h ₁₀).

This concludes the proof. 

What is claimed is:
 1. An application specific integrated circuit (ASIC) tangibly encoding a program of instructions executable by the integrated circuit to perform a method for fast Chase decoding of generalized Reed-Solomon (GRS) codes, the method comprising the steps of; using outputs of a syndrome-based hard-decision (HD) algorithm to find an initial Groebner basis G={g₀=(g₀₀, g₀₁), g₁=(g₁₀, g₁₁)} for a solution module of a key equation, upon failure of HD decoding of a GRS codeword received by the ASIC from a communication channel; traversing a tree of error patterns in E_(i₁) × … × E_(i_(n₀)) on a plurality of unreliable coordinates to adjoin a next weak coordinate wherein n₀ is a number of the unreliable coordinates, i₁, . . . , i_(n) ₀ are the unreliable coordinates, vertices of the tree of error patterns correspond to error patterns, and edges connect a parent error pattern to a child error pattern having exactly one additional non-zero value, to find a Groebner basis G⁺ for each adjoining error location; and outputting an estimated transmitted codeword {circumflex over (x)}:=y+ê when a correct error vector ê has been found.
 2. The ASIC of claim 1, wherein the syndrome-based HD algorithm is selected from a group that includes the Berlekamp-Massey (BM) algorithm and Fitzpatrick's algorithm.
 3. The ASIC of claim 1, wherein finding an initial Groebner basis G comprises: defining polynomials b₁:=(Sσ mod X^(d−1), σ), and b₂:=(SX^(m)B mod X^(d−1), X^(m)B), wherein S is the syndrome polynomial, σ is the estimated ELP output by the BM algorithm, m is the number of iterations since the last linear feedback shift register (LFSR) length change in the BM algorithm, and B is a polynomial output from the BM algorithm that is a copy of the last estimated ELP σ before the LFSR length L was updated; and outputting one of (1) c{b₁b₂} as the Groebner basis when leading monomials of b₁ and b₂ contain distinct unit vectors, for a. non-zero constant c; (2) {d(b₁−cX^(l)b₂), db₂} as the Groebner basis when the leading monomials contain a same unit vector and the leading monomial of b₁ is at least as large as that of b₂, wherein c∈K* and l∈N are chosen such that the leading monomial of b₂ is canceled and d is a non-zero constant, or (3) {db₁, d(b₂−cX^(l)b₁)} as the Groebner basis when the leading monomials contain the same unit vector and the leading monomial of b₂ is strictly larger than that of b₁, wherein c∈K* and l∈N* are chosen such that the leading monomial of b₂ is canceled and d is a non-zero constant.
 4. The ASIC of claim 1, wherein traversing a tree of error patterns to find a Groebner basis G⁺ for each adjoining error location comprises: calculating a root discrepancy Δ_(j) ^(rt):=g^(j1)(α_(r) ⁻¹) for j=0 and 1, wherein g₀=(g₀₀(X), g₀₁(X)) and g₁=(g₁₀(X), g₁₁(X)) constitute a current Groebner basis and α_(r)is a next error location and r is a number of error locations; setting, when a set ${J:={\left\{ {j \in \left\{ {0,1} \right\}} \middle| {\Delta_{j}^{rt} \neq 0} \right\} \neq \varnothing}},{g_{j}^{+}:={c\left( {g_{j} - {\frac{\Delta_{j}^{rt}}{\Delta_{j*}^{rt}}g_{j*}}} \right)}}$ when (j≠j*), wherein j*∈E is such that a leading monomial of g_(j*) is a minimum leading monomial of (g_(j)) for all j∈J and c is a non-zero constant, or g⁺ _(j):=c(X−α_(r) ⁻¹)g_(j*) when j=j*, wherein X is a free variable; setting g_(j):=g⁺ _(j) for j=0 and 1; calculating a derivative discrepancy Δ_(j) ^(der):=β_(r)α_(r)g′_(j1)(α_(r) ⁻¹)+α_(r)g_(j0)(α_(r) ⁻¹) for j=0 and 1, wherein β_(r) is a value of location α_(r), and g′_(j1)(X) is a formal derivative of g_(j1)(X); setting, when a set ${J:={\left\{ {j \in \left\{ {0,1} \right\}} \middle| {\Delta_{j}^{der} \neq 0} \right\} \neq \varnothing}},{g_{j}^{+}:={c\left( {g_{j} - {\frac{\Delta_{j}^{der}}{\Delta_{j*}^{der}}g_{j*}}} \right)}}$ when (j≠j), wherein j*∈J is such that a leading monomial of M(g_(j*))=a minimum leading monomial of (g_(j)) for all j∈J and c is a non-zero constant, or g⁺ _(j):=c(X−α_(r) ⁻¹)g_(j*) when j=j*.
 5. The ASIC of claim 4, further comprising, when set J:={j∈{0, 1}|Δ_(j) ^(rt)≠0}=Ø or when set J:={j∈{0, 1}|Δ_(j) ^(der)≠0}=Ø, setting g⁺ _(j):=g_(j) for j=0, 1, wherein g⁺ ₀=(g⁺ ₀₀, g⁺ ₀₁) and g⁺ ₁=(g⁺ ₁₀, g⁺ ₁₁) is a Groebner basis G⁺ for the next error locator.
 6. The ASIC of claim 4, the method further comprising determining whether a root discrepancy is zero for j=1 and a derivative discrepancy is zero for j=1, and stopping setting of g⁺ _(j), if it is determined that both the root discrepancy and the derivative discrepancy are zero for j=1.
 7. The ASIC of claim 4, further comprising tracking a degree of Groebner basis function g₀₀ with a variable d₀ by increasing d₀ by 1 whenever j*=0.
 8. The ASIC of claim 4, further comprising; tracking two polynomials g₀₁(X), g₁₁(X); and calculating g_(j0)(α_(r) ⁻¹) by using the key equation for j=0,1.
 9. The ASIC of claim 8, wherein calculating g_(j0)(α_(r) ⁻¹) comprises: calculating and storing, for k=2t−δ−1 to 2t−2, {tilde over (B)}_(k+1)=α_(r) ⁻¹·{tilde over (B)}_(k)−(g_(j1))_(2t−1−k) and result=result+S_(k+1){tilde over (B)}_(k+1), wherein δ:=deg(g_(j1)), {tilde over (B)}_(k) is initialized to 0, (g_(j1))_(m) is a coefficient of X^(m) in g_(j1), result is initialized to 0, and S_(k+1) is a coefficient of the syndrome polynomial; updating result=result·(α_(r) ⁻¹)^(2t); and outputting result, wherein the steps of calculating and storing, for k=2t−δ−1 to 2t−2, {tilde over (B)}_(k+1) and result, updating result and outputting result are performed while adjoining the next weak coordinate α_(r).
 10. The ASIC of claim 9, further comprising calculating and storing (α_(m) ⁻¹)^(2t) for all weak coordinates a_(m), wherein t=└(d−1)/2┘ is an error correction radius of a GRS code of designed distance d.
 11. A non-transitory program storage device readable by a computer, tangibly embodying a program of instructions executed by the computer to perform the method steps for fast Chase decoding of generalized Reed-Solomon (GRS) codes, the method comprising the steps of: using outputs of a syndrome-based hard-decision (HD) algorithm to find an initial Groebner basis G={g₀=(g₀₀, g₀₁), g₁=(g₁₀, g₁₁)} for a solution module of a key equation, upon failure of HD decoding of a GRS codeword received by the ASIC from a communication channel; traversing a tree of error patterns in E_(i₁) × … × E_(i_(n₀)) on a plurality of unreliable coordinates to adjoin a next weak coordinate wherein n₀ is a number of the unreliable coordinates, i₁, . . . , i_(n) ₀ are the unreliable coordinates, vertices of the tree of error patterns correspond to error patterns, and edges connect a parent error pattern to a child error pattern having exactly one additional non-zero value, to find a Groebner basis G⁺ for each adjoining error location; and outputting an estimated transmitted codeword {circumflex over (x)}:=y+ê when a correct error vector ê has been found.
 12. The computer readable program storage device of claim 11, wherein the syndrome-based HD algorithm is selected from a group that includes the Berlekamp-Massey (BM) algorithm and Fitzpatrick's algorithm.
 13. The computer readable program storage device of claim 11, wherein finding an initial Groebner basis G comprises: defining polynomials b₁:=(Sσ mod X^(d−1), σ), and b₂:=(SX^(m)B mod X^(d−1), X^(m)B), wherein S is the syndrome polynomial, σ is the estimated FIT output by the BM algorithm, m is the number of iterations since the last linear feedback shift register (LFSR) length change in the BM algorithm, and B is a polynomial output from the BM algorithm that is a copy of the last estimated ELP a before the LFSR length L was updated; and outputting one of (1) c{b₁b₂} as the Groebner basis when leading monomials of b₁ and b₂ contain distinct unit vectors, for a non-zero constant c; (2) {d(b₁−cX^(l)b₂), db₂} as the Groebner basis when the leading monomials contain a same unit vector and the leading monomial of b₁ is at least as large as that of b₂, wherein c∈K* and l∈N are chosen such that the leading monomial of b₂ is canceled and d is a non-zero constant, or (3) {db₁, d(b₂−cX^(l)b₁)} as the Groebner basis when the leading monomials contain the same unit vector and the leading monomial of b₂ is strictly larger than that of b₁, wherein c∈K* and l∈N* are chosen such that the leading monomial of b₂ is canceled and d is a non-zero constant.
 14. The computer readable program storage device of claim 11, wherein traversing a tree of error patterns to find a Groebner basis G⁺ for each adjoining error location comprises: calculating a root discrepancy Δ_(j) ^(rt):=g^(j1)(α_(r) ⁻¹) for j=0 and 1, wherein g₀=(g₀₀(X), g₀₁(X)) and g₁=(g₁₀(X), g₁₁(X)) constitute a current Groebner basis and α_(r)is a next error location and r is a number of error locations; setting, when a set ${J:={\left\{ {j \in \left\{ {0,1} \right\}} \middle| {\Delta_{j}^{rt} \neq 0} \right\} \neq \varnothing}},{g_{j}^{+}:={c\left( {g_{j} - {\frac{\Delta_{j}^{rt}}{\Delta_{j*}^{rt}}g_{j*}}} \right)}}$ when (j≠j*), wherein j*∈E is such that a leading monomial of g_(j*) is a minimum leading monomial of (g_(j)) for all j∈J and c is a non-zero constant, or g⁺ _(j):=c(X−α_(r) ⁻¹)g_(j*) when j=j*, wherein X is a free variable; setting g_(j):=g⁺ _(j) for j=0 and 1; calculating a derivative discrepancy Δ_(j) ^(der):=β_(r)α_(r)g′_(j1)(α_(r) ⁻¹)+α_(r)g_(j0)(α_(r) ⁻¹) for j=0 and 1, wherein β_(r) is a value of location α_(r), and g′_(j1)(X) is a formal derivative of g_(j1)(X); setting, when a set ${J:={\left\{ {j \in \left\{ {0,1} \right\}} \middle| {\Delta_{j}^{der} \neq 0} \right\} \neq \varnothing}},{g_{j}^{+}:={c\left( {g_{j} - {\frac{\Delta_{j}^{der}}{\Delta_{j*}^{der}}g_{j*}}} \right)}}$ when (j≠j), wherein j*∈J is such that a leading monomial of M(g_(j*))=a minimum leading monomial of (g_(j)) for all j∈J and c is a non-zero constant, or g⁺ _(j):=c(X−α_(r) ⁻¹)g_(j*) when j=j*.
 15. The computer readable program storage device of claim 14, further comprising, when set J:={j∈{0, 1}|Δ_(j) ^(rt)≠0}=Ø or when set J:={j∈{0, 1}|Δ_(j) ^(der)≠0}=Ø, setting g⁺ _(j):=g_(j) for j=0, 1, wherein g⁺ ₀=(g⁺ ₀₀, g⁺ ₀₁) and g⁺ ₁=(g⁺ ₁₀, g⁺ ₁₁) is a Groebner basis G⁺ for the next error locator.
 16. The computer readable program storage device of claim 14, the method further comprising determining whether a root discrepancy is zero for j=1 and a derivative discrepancy is zero for j=1, and stopping setting of g⁺ _(j), if it is determined that both the root discrepancy and the derivative discrepancy are zero for j=1.
 17. The computer readable program storage device of claim 14, further comprising tracking a degree of Groebner basis function g₀₀ with a variable d₀ by increasing d₀ by 1 whenever j*=0.
 18. The computer readable program storage device of claim 14, further comprising: tracking two polynomials g₀₁(X)q₁₁(X); and calculating g_(j0)(α_(r) ⁻¹) by using the key equation for j=0,1.
 19. The computer readable program storage device of claim 18, wherein calculating g_(j0)(α_(r) ⁻¹) comprises: calculating and storing, for k=2t−δ−1 to 2t−2, {tilde over (B)}_(k+1)=α_(r) ⁻¹·{tilde over (B)}_(k)−(g_(j1))_(2t−1−k) and result=result+S_(k+1){tilde over (B)}_(k+1), wherein δ:=deg(g_(j1)), {tilde over (B)}_(k) is initialized to 0, (g_(j1))_(m) is a coefficient of X^(m) in g_(j1), result is initialized to 0, and S_(k+1) is a coefficient of the syndrome polynomial; updating result=result·(α_(r) ⁻¹)^(2t); and outputting result, wherein the steps of calculating and storing, for k=2t−δ−1 to 2t−2, {tilde over (B)}_(k+1) and result, updating result and outputting result are performed while adjoining the next weak coordinate α_(r).
 20. The computer readable program storage device of claim 19, further comprising calculating and storing (α_(m) ⁻¹)^(2t) for all weak coordinates a_(m), wherein t=[((d−1)/2] is an error correction radius of a GRS code of designed distance d. 